home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 3 / BBS in a box - Trilogy III.iso / Files / Prog / D-G / DropInfo ƒ / DI⁄C / DSUserProcs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-22  |  6.7 KB  |  209 lines  |  [TEXT/MPS ]
  1. /******************************************************************************
  2. **
  3. **  Project Name:    DropInfo
  4. **     File Name:    DSUserProcs.c
  5. **
  6. **   Description:    Specific AppleEvent handlers used by the DropBox
  7. **
  8. *******************************************************************************
  9. **                       A U T H O R   I D E N T I T Y
  10. *******************************************************************************
  11. **
  12. **    Initials    Name
  13. **    --------    -----------------------------------------------
  14. **    LDR            Leonard Rosenthol
  15. **    MTC            Marshall Clow
  16. **    SCS            Stephan Somogyi
  17. **
  18. *******************************************************************************
  19. **                      R E V I S I O N   H I S T O R Y
  20. *******************************************************************************
  21. **
  22. **      Date        Time    Author    Description
  23. **    --------    -----    ------    ---------------------------------------------
  24. **    12/20/91            LDR        Modified for DropInfo
  25. **    12/09/91            LDR        Added the new SelectFile userProc
  26. **                                Added the new Install & DisposeUserGlobals procs
  27. **                                Modified PostFlight to only autoquit on odoc, not pdoc
  28. **    11/24/91            LDR        Added the userProcs for pdoc handler
  29. **                                Cleaned up the placement of braces
  30. **                                Added the passing of a userDataHandle
  31. **    10/29/91            SCS        Changes for THINK C 5
  32. **    10/28/91            LDR        Officially renamed DropShell (from QuickShell)
  33. **                                Added a bunch of comments for clarification
  34. **    10/06/91    00:02    MTC        Converted to MPW C
  35. **    04/09/91    00:02    LDR        Added to Projector
  36. **
  37. ******************************************************************************/
  38.  
  39.  
  40. #include "DSGlobals.h"
  41. #include "DSUserProcs.h"
  42.  
  43. /*
  44.     This routine is called during init time.
  45.     
  46.     It allows you to install more AEVT Handlers beyond the standard four
  47. */
  48. #pragma segment AEVT
  49. pascal void InstallOtherEvents (void) {
  50. }
  51.  
  52.  
  53. /*    
  54.     This routine is called when an OAPP event is received.
  55.     
  56.     Currently, all it does is set the gOApped flag, so you know that
  57.     you were called initally with no docs, and therefore you shouldn't 
  58.     quit when done processing any following odocs.
  59. */
  60. #pragma segment AEVT
  61. pascal void OpenApp (void) {
  62.     gOApped = true;
  63. }
  64.  
  65.  
  66. /*    
  67.     This routine is called when an QUIT event is received.
  68.     
  69.     We simply set the global done flag so that the main event loop can
  70.     gracefully exit.  We DO NOT call ExitToShell for two reasons:
  71.     1) It is a pretty ugly thing to do, but more importantly
  72.     2) The Apple event manager will get REAL upset!
  73. */
  74. #pragma segment AEVT
  75. pascal void QuitApp (void) {
  76.     gDone = true;    /*    All Done! */
  77. }
  78.  
  79.  
  80. /*    
  81.     This routine is the first one called when an ODOC or PDOC event is received.
  82.     
  83.     In this routine you would place code used to setup structures, etc. 
  84.     which would be used in a 'for all docs' situation (like "Archive all
  85.     dropped files")
  86.  
  87.     Obviously, the opening boolean tells you whether you should be opening
  88.     or printing these files based on the type of event recieved.
  89.     
  90.     userDataHandle is a handle that you can create & use to store your own
  91.     data structs.  This dataHandle will be passed around to the other 
  92.     odoc/pdoc routines so that you can get at your data without using
  93.     globals - just like the new StandardFile.  
  94.     
  95.     We also return a boolean to tell the caller if you support this type
  96.     of event.  By default, our dropboxes don't support the pdoc, so when
  97.     opening is FALSE, we return FALSE to let the caller send back the
  98.     proper error code to the AEManager.
  99.  
  100.     You will probably want to remove the #pragma unused (currently there to fool the compiler!)
  101. */
  102. #pragma segment AEVT
  103. pascal Boolean PreFlightDocs (Boolean opening, const Handle *userDataHandle) {
  104. #pragma unused ( userDataHandle )
  105.  
  106.     return opening;        // we support opening, but not printing - see above
  107. }
  108.  
  109.  
  110. /*    
  111.     This routine is called for each file passed in the ODOC event.
  112.     
  113.     In this routine you would place code for processing each file/folder/disk that
  114.     was dropped on top of you.
  115.     
  116.     You will probably want to remove the #pragma unused (currently there to fool the compiler!)
  117. */
  118. #pragma segment AEVT
  119. pascal void OpenDoc ( FSSpecPtr myFSSPtr, Boolean opening, const Handle userDataHandle ) {
  120. #pragma unused ( userDataHandle )
  121.  
  122.     if (opening)
  123.         GetTheInfo(myFSSPtr);
  124. }
  125.  
  126.  
  127. /*    
  128.     This routine is the last routine called as part of an ODOC event.
  129.     
  130.     In this routine you would place code to process any structures, etc. 
  131.     that you setup in the PreflightDocs routine.
  132.  
  133.     If you created a userDataHandle in the PreFlightDocs routines, this is
  134.     the place to dispose of it since the Shell will NOT do it for you!
  135.     
  136.     You will probably want to remove the #pragma unusued (currently there to fool the compiler!)
  137. */
  138. #pragma segment AEVT
  139. pascal void PostFlightDocs ( Boolean opening, const Handle userDataHandle ) {
  140. #pragma unused ( userDataHandle )
  141.  
  142.     extern Boolean gChgAll, gWarned, gOnlyOne;
  143.     
  144.     // reset some dropInfo specific globals
  145.     gChgAll = gWarned = gOnlyOne = 0;
  146.  
  147.     if ( (opening) && (!gOApped) )
  148.         gDone = true;    /*    close everything up! */
  149.  
  150.     /*
  151.         The reason we do not auto quit is based on a recommendation in the
  152.         Apple event Registry which specifically states that you should NOT
  153.         quit on a 'pdoc' as the Finder will send you a 'quit' when it is 
  154.         ready for you to do so.
  155.     */
  156. }
  157.  
  158.  
  159. /*
  160.     This routine is called when the user chooses "Select File…" from the
  161.     File Menu.
  162.     
  163.     Currently it simply calls the new StandardGetFile routine to have the
  164.     user select a single file (any type, numTypes = -1) and then calls the
  165.     SendODOCToSelf routine in order to process it.  
  166.             
  167.     The reason we send an odoc to ourselves is two fold: 1) it keeps the code
  168.     cleaner as all file openings go through the same process, and 2) if events
  169.     are ever recordable, the right things happen (this is called Factoring!)
  170.  
  171.     Modification of this routine to only select certain types of files, selection
  172.     of multiple files, and/or handling of folder & disk selection is left 
  173.     as an exercise to the reader.
  174. */
  175. pascal void SelectFile (void)
  176. {
  177.     StandardFileReply    stdReply;
  178.     SFTypeList            theTypeList;
  179.  
  180.     StandardGetFile(NULL, -1, theTypeList, &stdReply);
  181.     if (stdReply.sfGood)    // user did not cancel
  182.         SendODOCToSelf(&stdReply.sfFile);    // so send me an event!
  183. }
  184.  
  185. /*
  186.     This routine is called during the program's initialization and gives you
  187.     a chance to allocate or initialize any of your own globals that your
  188.     dropbox needs.
  189.     
  190.     You return a boolean value which determines if you were successful.
  191.     Returning false will cause DropShell to exit immediately.
  192. */
  193. pascal Boolean InitUserGlobals(void)
  194. {
  195.     extern Boolean gChgAll, gWarned, gOnlyOne;
  196.     gChgAll = gWarned = gOnlyOne = 0;
  197.     return(true);    // not much to do, so we must be successful!
  198. }
  199.  
  200. /*
  201.     This routine is called during the program's cleanup and gives you
  202.     a chance to deallocate any of your own globals that you allocated 
  203.     in the above routine.
  204. */
  205. pascal void DisposeUserGlobals(void)
  206. {
  207.     // nothing to do for our sample dropbox
  208. }
  209.